<!DOCTYPE html>
<html lang="zh-Hans">

<!-- Head tag -->
<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <!--Description-->
    
        <meta name="description" content="Note">
    

    <!--Author-->
    
        <meta name="author" content="兰陵忧患生">
    

    <!-- Title -->
    
    <title>第十四章 多线程 | Lan</title>

    <!-- Bootstrap Core CSS -->
    <link href="//cdn.bootcss.com/bootstrap/3.3.6/css/bootstrap.min.css" rel="stylesheet">
    <link rel="stylesheet"
      href="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.12.0/build/styles/default.min.css">
    <script src="//cdn.jsdelivr.net/gh/highlightjs/cdn-release@9.12.0/build/highlight.min.js"></script>

    <!-- Custom CSS -->
    <link rel="stylesheet" href="/css/style.css">

    <!-- Custom Fonts -->
    <link href="//cdn.bootcss.com/font-awesome/4.5.0/css/font-awesome.min.css" rel="stylesheet" type="text/css">
    <link href='//fonts.googleapis.com/css?family=Lora:400,700,400italic,700italic' rel='stylesheet' type='text/css'>
    <link href='//fonts.googleapis.com/css?family=Open+Sans:300italic,400italic,600italic,700italic,800italic,400,300,600,700,800' rel='stylesheet' type='text/css'>

    <!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    <script src="https://oss.maxcdn.com/libs/html5shiv/3.7.0/html5shiv.js"></script>
    <script src="https://oss.maxcdn.com/libs/respond.js/1.4.2/respond.min.js"></script>
    <![endif]-->
</head>

<body>

    <!-- Content -->
    <section class="article-container">
<!-- Back Home -->
<a class="nav-back" href="/">
    <i class="fa fa-puzzle-piece"></i>
</a>

<!-- Page Header -->
<header class="intro-header">
    <div class="container">
        <div class="row">
            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                <div class="post-heading">
                    <h1>第十四章 多线程</h1>
                </div>
            </div>
        </div>
    </div>
</header>

<!-- Post Content -->
<article>
    <div class="container">
        <div class="row">
            <!-- TOC -->
            <div class="toc-article col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
    <ol class="toc"><li class="toc-item toc-level-1"><a class="toc-link" href="#多线程"><span class="toc-text">多线程</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#中断线程"><span class="toc-text">中断线程</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#线程状态"><span class="toc-text">线程状态</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#可运行线程"><span class="toc-text">可运行线程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#被阻塞线程和等待线程"><span class="toc-text">被阻塞线程和等待线程</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#被终止的线程"><span class="toc-text">被终止的线程</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#线程属性"><span class="toc-text">线程属性</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#线程优先级"><span class="toc-text">线程优先级</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#守护线程"><span class="toc-text">守护线程</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#未捕获异常处理器"><span class="toc-text">未捕获异常处理器</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#同步"><span class="toc-text">同步</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#锁对象"><span class="toc-text">锁对象</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#条件对象"><span class="toc-text">条件对象</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#synchronized关键字"><span class="toc-text">synchronized关键字</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#同步阻塞"><span class="toc-text">同步阻塞</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#监视器概念"><span class="toc-text">监视器概念</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Volatile-域"><span class="toc-text">Volatile 域</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#final变量"><span class="toc-text">final变量</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#原子性"><span class="toc-text">原子性</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#死锁"><span class="toc-text">死锁</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#线程局部变量"><span class="toc-text">线程局部变量</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#锁测试与超时"><span class="toc-text">锁测试与超时</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#读／写锁"><span class="toc-text">读／写锁</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#为什么弃用-stop-和-suspend-方法"><span class="toc-text">为什么弃用 stop 和 suspend 方法</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#阻塞队列"><span class="toc-text">阻塞队列</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#线程安全的集合"><span class="toc-text">线程安全的集合</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#高效的映射表，集合和队列"><span class="toc-text">高效的映射表，集合和队列</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#写数组的拷贝"><span class="toc-text">写数组的拷贝</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#较早的线程安全集合"><span class="toc-text">较早的线程安全集合</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#Callable-和-Future"><span class="toc-text">Callable 和 Future</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#执行器"><span class="toc-text">执行器</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#线程池"><span class="toc-text">线程池</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#预定执行"><span class="toc-text">预定执行</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#控制任务组"><span class="toc-text">控制任务组</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Fork-Join-框架（-Java-SE-7-）"><span class="toc-text">Fork-Join 框架（ Java SE 7 ）</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#同步器"><span class="toc-text">同步器</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#信号量"><span class="toc-text">信号量</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#倒计时门栓"><span class="toc-text">倒计时门栓</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#障栅"><span class="toc-text">障栅</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#交换器"><span class="toc-text">交换器</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#同步队列"><span class="toc-text">同步队列</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#线程与-Swing"><span class="toc-text">线程与 Swing</span></a></li></ol></li></ol>
</div>

            <!-- Post Main Content -->
            <div class="post-content col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                <h1 id="多线程"><a href="#多线程" class="headerlink" title="多线程"></a>多线程</h1><ul>
<li>多进程和多线程本质的区别在于每个进程拥有自己的一整套变量，而线程则共享数据。</li>
</ul>
<h2 id="中断线程"><a href="#中断线程" class="headerlink" title="中断线程"></a>中断线程</h2><ul>
<li>强制线程终止的方法。（interrupt）</li>
</ul>
<pre><code class="Java">// Thread.currentThread()获取当前线程
while(!Thread.currentThread().isInterrupted() &amp;&amp; more work to do)
{
    do more work
}
// 如果线程被阻塞，就无法检测中断状态
</code></pre>
<pre><code class="Java">java.lang.Thread 1.0
void interrupt() //向线程发送中断请求。线程的中断状态将被设置为true。如果目前该线程被一个sleep调用阻塞，那么，InterruptedException异常被抛出
static boolean interrupted() // 测试当前线程是否被中断。静态方法。副作用：它将当前线程的中断状态重置为false
boolean isInterrupted() // 测试线程是否被终止。这一调用不改变线程的中断状态
static Thread currentThread() // 返回代表当前执行线程的Thread对象
</code></pre>
<h2 id="线程状态"><a href="#线程状态" class="headerlink" title="线程状态"></a>线程状态</h2><ul>
<li><p>线程的6种状态(getState方法确定线程的当前状态)</p>
<ul>
<li>New (新创建)</li>
<li>Runnable (可运行)</li>
<li>Blocked (被阻塞)</li>
<li>Waiting (等待)</li>
<li>Timed waiting (计时等待)</li>
<li>Terminated (被终止)</li>
</ul>
</li>
</ul>
<h3 id="可运行线程"><a href="#可运行线程" class="headerlink" title="可运行线程"></a>可运行线程</h3><ul>
<li><p>调度系统</p>
<ul>
<li>抢占式调度系统 （时间片，优先级）桌面以及服务器操作系统</li>
<li>协作式调度系统 （一个线程只有在调用yield方法或者被阻塞或等待时，线程才失去控制权）</li>
</ul>
</li>
<li><p>在如何给定的时刻，一个可运行的线程可能正在运行也可能没有运行。</p>
</li>
</ul>
<h3 id="被阻塞线程和等待线程"><a href="#被阻塞线程和等待线程" class="headerlink" title="被阻塞线程和等待线程"></a>被阻塞线程和等待线程</h3><h3 id="被终止的线程"><a href="#被终止的线程" class="headerlink" title="被终止的线程"></a>被终止的线程</h3><ul>
<li><p>终止原因</p>
<ul>
<li>因为run方法正常退出而自然死亡</li>
<li>因为一个没有捕获的异常终止了run方法而意外死亡</li>
</ul>
</li>
</ul>
<pre><code class="Java">void join() // 等待终止指定的线程
void join(long millis) // 等待指定的线程死亡或者经过指定的毫秒数。
Thread.State getState() 5.0 // 得到这一线程的状态；NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING或TERMINATED之一
</code></pre>
<h2 id="线程属性"><a href="#线程属性" class="headerlink" title="线程属性"></a>线程属性</h2><ul>
<li>线程优先级，守护线程，线程组以及处理未捕获异常的处理器</li>
</ul>
<h3 id="线程优先级"><a href="#线程优先级" class="headerlink" title="线程优先级"></a>线程优先级</h3><ul>
<li>一个线程继承它的父线程的优先级。</li>
<li>线程优先级是高度依赖于系统的。当虚拟机依赖于宿主机平台的线程实现机制时，Java线程的优先级被映射到宿主机平台的优先级上。如：Windows有7个优先级。一些Java优先级将映射到相同的操作系统优先级。在Sun为Linux提供的Java虚拟机，线程的优先级别忽略-所有线程具有相同的优先级</li>
<li>不要将程序构建为功能的正确性依赖于优先级</li>
</ul>
<pre><code class="Java">java.lang.Thread 1.0
void setPriority(int newPriority) // 设置线程的优先级一般使用Thread.NORM_PRIORITY优先级
static int MIN_PRIORITY // 线程的最小优先级。值为1
static int NORM_PRIORITY // 线程的默认优先级。默认优先级为5
static int MAX_PRIORITY // 线程的最高优先级。值为10
static void yield() 导致当前执行线程处于让步状态。如果有其他的可运行线程具有至少与线程同样高的优先级，那么这些线程接下来会被调度。
</code></pre>
<h2 id="守护线程"><a href="#守护线程" class="headerlink" title="守护线程"></a>守护线程</h2><pre><code class="Java">java.lang.Thread 1.0
t.setDaemon(true); // 标识该线程为守护线程(daemon thread)或用户线程。
// 用途是为其他线程提供服务
</code></pre>
<h3 id="未捕获异常处理器"><a href="#未捕获异常处理器" class="headerlink" title="未捕获异常处理器"></a>未捕获异常处理器</h3><ul>
<li><p>线程的run方法不能抛出任何被检测的异常，但是，不被检测的异常会导致线程终止。</p>
</li>
<li><p>不需要任何catch子句来处理可以别传播的异常。在线程死亡之前，异常被传到一个用于捕获异常的处理器。该处理器必须实现Thread.UncaughtExceptionHandler接口的类。可以使用setUncaughtExceptionHandler 为任何线程安装一个处理器。</p>
</li>
<li><p>也可以使用Thread类的静态方法setDefaultUncaughtExceptionHandler为所有线程安装一个默认的处理器。</p>
</li>
<li><p>线程组是一个可以统一管理的线程集合。默认情况下，创建的所有线程属于相同的线程组。</p>
</li>
<li><p>ThreadGroup类实现Thread.UncaughtExceptionHandler接口。它的uncaughtException方法做法：</p>
<ul>
<li>如果改线程组有父线程组，那么父线程组的uncaughtException方法被调用。</li>
<li>否则，如果Thread.getDefaultExceptionHandler方法返回一个非空的处理器，则调用该处理器</li>
<li>否则，如果Throwable是ThreadDeath的一个实例，什么都不做。</li>
<li>否则，线程的名字以及Throwable的栈踪迹被输出到System.err上。</li>
</ul>
</li>
</ul>
<pre><code class="Java">java.lang.Thread 1.0
static void setDefaultUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler) 5.0
static ThreadUncaughtExceptionHandler getDefaultUncaughtExceptionHandler() 5.0
// 设置或获取为捕获异常的默认处理器
void setUncaughtExceptionHandler(Thread.UncaughtExceptionHandler handler) 5.0
// 设置或捕获异常的处理器。如果没有安装处理器，则将线程组对象作为处理器。

java.lang.Thread.UncaughtExceptionHandler 5.0
void uncaughtException(Thread t, Throwable e)
// 当一个线程因未捕获异常而终止，按规定要将客户报告记录到日志中。t：由于未捕获异常而终止的线程 e：未捕获的异常对象

java.lang.ThreadGroup 1.0
void uncaughtException(Thread t, Throwable e)
</code></pre>
<h2 id="同步"><a href="#同步" class="headerlink" title="同步"></a>同步</h2><ul>
<li>根据各线程访问数据的次序，可能会产生讹误的对象。称为竞争条件（race condition）</li>
<li>同步存取</li>
<li>查看类中每一个语句的虚拟机的字节码。<code>javap -c -v Bank</code>，对Bank.class文件进行反编译，重要的是增值命令是由几条指令组成的，执行它们的线程可以在任何一条指令点上被中断。</li>
</ul>
<h3 id="锁对象"><a href="#锁对象" class="headerlink" title="锁对象"></a>锁对象</h3><ul>
<li>Java语言提供了一个synchronized关键字达到这一目的，Java SE 5.0 引入了ReentrantLock类。</li>
</ul>
<pre><code class="Java">// ReentrantLock
myLock.lock(); // a ReentrantLock object
try
{
    critical section
}
finally
{
 myLock.unlock(); // make sure the lock is unlocked even if an exception is thrown
}
// 确保任何时刻只有一个线程进入临界区。
// 一旦一个线程封锁了锁对象，其他任何线程都无法通过lock语句。当其他线程调用lock时，它们被阻塞，直到第一个线程释放锁对象。
// 把解锁对象括在finally子句之内是至关重要的。如果在临界区的代码跑出异常，锁必须别释放。否则，其他线程将永远阻塞。
</code></pre>
<ul>
<li><p>使用锁，就不能使用带有资源的try语句。</p>
</li>
<li><p>每一个Bank对象有自己的ReentrantLock对象。如果两个线程试图访问同一个Bank对象，那么锁以串行方式提供服务。但是，如果两个线程访问不同的Bank对象，每一个线程得到不同的锁对象，两个线程都不会发生阻塞。</p>
</li>
<li>锁是可重入的，因为线程可以重复地获得已经持有的锁。锁保持一个持有计数(hold count)来跟踪对lock方法等嵌套调用被一个锁保护的代码可以调用另一个使用相同的锁的方法。</li>
</ul>
<pre><code class="Java">java.util.concurrent.locks.Lock 5.0
void lock(); // 获得这个锁；如果锁同时被另一个线程拥有则发生阻塞
void unlock(); // 释放这个锁

java.util.concurrent.locks.ReentrantLock 5.0
ReentrantLock(); // 构建一个可以被用来保护临界区等可重入锁
ReentrantLock(boolean fair); // 构建一个带有公平策略的锁。一个公平锁偏爱等待时间最长的线程。
</code></pre>
<h3 id="条件对象"><a href="#条件对象" class="headerlink" title="条件对象"></a>条件对象</h3><ul>
<li>一旦一个线程调用await方法，它进入该条件的等待集。当锁可用时，该线程不能马上解除阻塞。相反，它处于阻塞状态，直到另一个线程调用同一个条件上的singalAll方法时为止。</li>
<li>当一个线程拥有某个条件的锁时，它仅仅可以在该条件上调用await，signalAll或signal方法。</li>
</ul>
<pre><code class="Java">java.util.concurrent.locks.Lock 5.0
Condition newCondition() // 返回一个与该锁相关的条件对象

java.util.concurrent.locks.Condition 5.0
void await() // 将该线程放到条件的等待集中
void signalAll() // 解除该条件的等待集中的所欲线程的阻塞状态
void signal() // 从该条件的等待集中随机地选择一个线程，解除其阻塞状态
</code></pre>
<h3 id="synchronized关键字"><a href="#synchronized关键字" class="headerlink" title="synchronized关键字"></a>synchronized关键字</h3><ul>
<li><p>总结：</p>
<ul>
<li>锁用来保护代码片段，任何时刻只能有一个线程执行被保护的代码。</li>
<li>锁可以管理试图进入被保护代码段段线程。</li>
<li>锁可以拥有一个或多个相关的条件对象。</li>
<li>每个条件对象管理那些已经进入被保护的代码段但还不能运行的线程。</li>
</ul>
</li>
<li><p>从1.0版开始，Java中的每一个对象都有一个内部锁。</p>
<pre><code class="java">  public synchronized void method()
  {
      method body
  }
  // 等价于
  public void method()
  {
      this.intrinsicLock.lock();
      try
      {
          method body
      }
      finally
      {
          this.intrinsicLock.unlock();
      }
  }
</code></pre>
</li>
<li><p>wait 方法添加一个线程到等待集中，notifyAll/notify 方法解除等待线程的阻塞状态。</p>
<pre><code class="Java">  // 等价于
  intrinsicCondition.await();
  intrinsicCondition.signalAll();
</code></pre>
</li>
<li><p>wait, notifyAll以及notify方法是Object类的final方法。Condition方法必须被命名为 await, signalAll 和 signal 以便它们不会与那些方法发生冲突</p>
</li>
<li><p>每一个对象有一个内部锁，并且该锁有一个内部条件。由锁来管理那些试图进入 synchronized 方法的线程，由条件来管理那些调用wait的线程。</p>
</li>
<li><p>将静态方法声明为 synchronized 也是合法的。当该方法调用时，对象的锁被锁住。因此没有其他线程可以调用同一个类的这个或如何其他的同步静态方法。</p>
</li>
<li><p>内部锁和条件存在一些局限。</p>
<ul>
<li>不能中断一个正在试图获得锁的线程。</li>
<li>试图获得锁时不能设定超时。</li>
<li>每个锁仅有单一的条件，可能是不够的。</li>
</ul>
</li>
<li><p>使用 Lock 和 Condition 对象还是同步方法</p>
<ul>
<li>最好既不使用 Lock/Condition 也不使用 synchronized 关键字。在许多情况下你可以使用 java.util.concurrent 包中的一种机制，它会为你处理所有的加锁。</li>
<li>如果 synchronized 关键字适合你的程序，那么尽管使用。</li>
<li>如果特别需要Lock/Condition结构提供的独有特性时，才使用Lock/Condition</li>
</ul>
</li>
</ul>
<h3 id="同步阻塞"><a href="#同步阻塞" class="headerlink" title="同步阻塞"></a>同步阻塞</h3><pre><code class="Java">synchronized(obj)
{
    critical section
}
// 获得obj的锁
</code></pre>
<h3 id="监视器概念"><a href="#监视器概念" class="headerlink" title="监视器概念"></a>监视器概念</h3><ul>
<li><p>监视器特征：</p>
<ul>
<li>监视器是只包含私有域的类。</li>
<li>每个监视器类的对象有一个相关的锁。</li>
<li>使用该锁对所有的方法进行加锁。obj.method()，obj对象的锁在方法调用开始时自动获得，并且当方法返回时自动释放该锁。</li>
<li>该锁可以有任意多个相关条件。</li>
</ul>
</li>
<li><p>每一个条件变量管理一个独立的线程集</p>
</li>
<li><p>3个方面Java对象不同于监视器，使得线程的安全性下降：</p>
<ul>
<li>域不要求必须是 private</li>
<li>方法不要求必须是 synchronized</li>
<li>内部锁对客户是可用的</li>
</ul>
</li>
</ul>
<h3 id="Volatile-域"><a href="#Volatile-域" class="headerlink" title="Volatile 域"></a>Volatile 域</h3><ul>
<li>如果向一个变量写入值，而这个变量接下来可能会被另一个线程读取，或者，从一个变量读值，而这个变量可能是之前被另一个线程写入的，此时必须使用同步。</li>
<li>volatile 关键字为实例域的同步访问提供了一种免锁机制。如果声明一个域为 volatile ，那么编译器和虚拟机就知道该域是可能被另一个线程并发更新的。</li>
</ul>
<pre><code class="Java">private boolean done;
public synchronized boolean isDone() { return done; }
public synchronized void setDone() { done = true; }
// 另一个线程已经对该对象加锁，isDone 和 setDone 可能阻塞。

private volatile boolean done;
public boolean isDone() { return done; }
public void setDone() { done = true; }
</code></pre>
<ul>
<li><p>Volatile 变量不能提供原子性。</p>
<pre><code class="Java">  public void flipDone() { done = !done;} // not atomic原子
  // 不能确保翻转域中的值
</code></pre>
</li>
</ul>
<h3 id="final变量"><a href="#final变量" class="headerlink" title="final变量"></a>final变量</h3><pre><code class="Java">final Map&lt;String, Double&gt; accounts = new HashMap&lt;&gt;();
// 其他线程会在构造函数完成构造之后才看到这个accounts变量
// 当然对这个映射表的操作并不是安全的。如果多个线程在读写这个映射表，仍然需要进行同步。
</code></pre>
<h3 id="原子性"><a href="#原子性" class="headerlink" title="原子性"></a>原子性</h3><ul>
<li><code>java.util.concurrent.atomic</code>包中有很多类使用了很高效的机器级指令（而不是使用锁）来保证其他操作的原子性。</li>
</ul>
<h3 id="死锁"><a href="#死锁" class="headerlink" title="死锁"></a>死锁</h3><ul>
<li>每一个线程要等待更多的钱款存入而导致所有线程都被阻塞。</li>
</ul>
<h3 id="线程局部变量"><a href="#线程局部变量" class="headerlink" title="线程局部变量"></a>线程局部变量</h3><pre><code class="Java">public static final ThreadLocal&lt;SimpleDateFormat&gt; dateFormat =
            new ThreadLocal&lt;SimpleDateFormat&gt;()
            {
                protected SimpleDateFormat initialValue()
                {
                    return new SimpleDateFormat(&quot;yyyy-MM-dd&quot;);
                }
            };
// java.util.Random 类是线程安全的。但是如果多个线程需要等待一个共享的随机数生成器，这会很低效。
// 使用ThreadLocal辅助类为各个线程提供一个单独的生成器
// Java SE 7 提供了一个便利类
in random = ThreadLocalRandom.current().nextInt(upperBond);
// ThreadLocalRandom.current() 调用会返回特定于当前线程的 Random 类实例

java.lang.ThreadLocal&lt;T&gt; 1.2
T get() // 得到这个线程的当前值。如果是首次调用get，会调用 initialize 来得到这个值。
protected initialize() // 应覆盖这个方法来提供一个初始值。默认情况下，这个方法返回 null
void set(T t) // 为这个线程设置一个新值
void remove() // 删除对应这个线程的值

java.util.concurrent.ThreadLocalRandom 7
static ThreadLocal Random current() // 返回特定于当前线程的 Random 类实例
</code></pre>
<h3 id="锁测试与超时"><a href="#锁测试与超时" class="headerlink" title="锁测试与超时"></a>锁测试与超时</h3><ul>
<li>线程在调用 lock 方法来获得另一个线程所持有的锁的时候，很可能发生阻塞。</li>
</ul>
<pre><code class="Java">if(myLock.tryLock())
    // now the thread owns the lock
    try { ... }
    finally { myLock.unlock(); }
else
    // do something else

// 使用超时参数
if(myLock.tryLock(100, TimeUnit.MILLSECONDS)) ...
// TimeUnit 是个枚举类型，可以取的值包括 SECONDS, MILLISECONDS, MICROSECONDS 和 NANOSECONDS
</code></pre>
<ul>
<li>lock 方法不能被中断。如果一个线程在等待获得一个锁时被中断，中断线程在获得锁之前一直处于阻塞状态。如果出现死锁，那么，lock 方法就无法终止。</li>
<li>调用超时参数的 tryLock，那么如果线程在等待期间被中断，将抛出 InterruptedException 异常。允许程序打破死锁</li>
<li><p>调用 lockInterruptibly 方法，它相当于一个超时设为无限的 tryLock 方法。</p>
<pre><code class="Java">  // 在等待一个条件时，也可以提供一个超时：
  myCondition.await(100, TimeUnit.MILLISECONDS))
</code></pre>
</li>
</ul>
<pre><code class="Java">java.util.concurrent.locks.Lock 5.0
boolean tryLock()
boolean tryLock(long time, TimeUnit unit) // 尝试获得锁，阻塞时间不会超过给定的值；如果成功返回true
void lockInterruptibly() // 获得锁，但是不确定地发生阻塞。如果线程被中断，抛出一个 InterruptedException 异常

java.util.concurrent.locks.Condition 5.0
boolean await(long time, TimeUnit unit) // 进入该条件等待集，直到线程从等待集中移除或等待了指定的时间之后才解除阻塞。
void awaitUninterruptibly()
</code></pre>
<h3 id="读／写锁"><a href="#读／写锁" class="headerlink" title="读／写锁"></a>读／写锁</h3><pre><code class="Java">// 构造一个 ReentrantReadWriteLock 对象
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
// 抽取读锁和写锁：
private Lock readLock = rwl.readLock();
private Lock WriteLock = rwl.writeLock();
// 对所有的获取方法加读锁：
public double getTotalBalance()
{
    readLock.lock();
    try { ... }
    finally { readLock.unlock(); }
}
// 对所有的修改方法加写锁
public void transfer(...)
{
    writeLock.lock();
    try { ... }
    finally { writeLock.unlock();}
}

java.util.concurrent.locks.ReentrantReadWriteLock 5.0
Lock readLock() // 得到一个可以被多个读操作共用的锁，但会排斥所有写操作。
Lock writeLock() // 得到一个写锁，排斥所有其他的读操作和写操作
</code></pre>
<h3 id="为什么弃用-stop-和-suspend-方法"><a href="#为什么弃用-stop-和-suspend-方法" class="headerlink" title="为什么弃用 stop 和 suspend 方法"></a>为什么弃用 stop 和 suspend 方法</h3><ul>
<li>stop 和 suspend 方法有一些共同点：都试图控制一个给定线程的行为</li>
<li>stop 终止所有未结束的方法，包括 run 方法。当线程被终止，立即释放。被它锁住的所有对象的锁。这会导致对象处于不一致的状态。</li>
<li>如果调用 suspend 方法的线程试图获得同一个锁，那么程序死锁：被挂起的线程等着恢复，而将其挂起的线程等待获得锁。</li>
</ul>
<pre><code class="Java">// 安全地挂起线程，引入一个变量 suspendRequested 并在 run 方法的某个安全的地方测试它。
private volatile boolean suspendRequested = false;
private Lock suspendLock = new ReentrantLock();
private Condition suspendCondition = suspendLock.newCondition();

public void run()
{
    while(...)
    {
        ...
        if(suspendRequested)
        {
            suspendLock.lock();
            try { while(suspendRequested) suspendCondition.await();}
            finally { suspendLock.unlock();}
        }
    }
}
public void requestSuspend() { suspendRequested = true;}
public void requestResume()
{
    suspendRequested = false;
    suspendLock.lock();
    try { suspendCondition.signalAll(); }
    finally { suspendLock.unlock();}
}
</code></pre>
<h2 id="阻塞队列"><a href="#阻塞队列" class="headerlink" title="阻塞队列"></a>阻塞队列</h2><ul>
<li><p>许多线程问题，可以通过使用一个或多个多个队列以优雅且安全的方式将其形式化。生产者线程向队列中插入元素，消费者线程则取出它们。</p>
</li>
<li><p>阻塞队列方法</p>
<pre><code class="java">  add     // 添加一个因素          // 如果队列满，则抛出 IllegalStateException 异常
  element // 返回队列的头元素       // 空，抛出 NoSuchElementException 异常
  offer   // 添加一个元素并返回 true// 满，返回 false
  peek    // 返回队列的头元素       // 空，返回 null
  poll    // 移出并返回队列的头元素. // 空，返回 null
  put     // 添加一个元素          // 满，则阻塞
  remove  // 移出并返回头元素       // 空，抛出 NoSuchElementException 异常
  take    // 移出并返回头元素       // 空，则阻塞

  // 如果将队列当作线程管理工具来使用，将要用到 put 和 take 方法
  // 在一个多线程程序中，队列会在任何时候空或满，一定要使用 offer,poll 和 peek 方法作为替代，这些方法如果不能完成任务，只是给出一个错误提示而不会抛出异常
  // poll 和 peek 方法返回空来指示失败。因此，向这些队列中插入 null 值是非法的

  // 超时 offer 方法 和 poll 方法的变体
  boolean success = q.offer(x, 100, TimeUnit.MILLISECONDS)
  Object head = q.poll(100, TimeUnit.MILLISECONDS)
</code></pre>
</li>
</ul>
<h2 id="线程安全的集合"><a href="#线程安全的集合" class="headerlink" title="线程安全的集合"></a>线程安全的集合</h2><h3 id="高效的映射表，集合和队列"><a href="#高效的映射表，集合和队列" class="headerlink" title="高效的映射表，集合和队列"></a>高效的映射表，集合和队列</h3><ul>
<li>java.util.concurrent 包提供了映射表，有序集和队列的高效实现：ConcurrentHashMap, ConcurrentSkipListMap, ConcurrentSkipListSet 和 ConcurrentLinkedQueue</li>
<li>集合返回弱一致性（weakly consistent）的迭代器。</li>
<li><p>ConcurrentHashMap 和 ConcurrentSkipListMap 类有相应的方法用于原子性的关联插入以及关联删除。</p>
<pre><code class="Java">  cache.putIfAbsent(key, value)
  cache.remove(key, value)
  // 将原子性地删除键值对，如果它们在映像表中出现的话。
  cache.replace(key, oldValue, newValue)
  // 原子性地用新值替换旧值，假定旧值与指定的键值关联
</code></pre>
</li>
</ul>
<h3 id="写数组的拷贝"><a href="#写数组的拷贝" class="headerlink" title="写数组的拷贝"></a>写数组的拷贝</h3><ul>
<li>CopyOnWriteArrayList 和 CopyOnWriteArraySet 是线程安全的集合，其中所有的修改线程对底层数组进行复制。</li>
</ul>
<h3 id="较早的线程安全集合"><a href="#较早的线程安全集合" class="headerlink" title="较早的线程安全集合"></a>较早的线程安全集合</h3><ul>
<li>Vector 和 Hashtable 类就提供线程安全的动态数组和散列表的实现。（被弃用了）</li>
<li><p>取而代之是 ArrayList 和 HashMap 类。这些类不是线程安全的，而集合库中提供了不同的机制。</p>
<pre><code class="Java">  // 任何集合类通过使用同步包装器 ( synchronization wrapper) 变成线程安全的
  List&lt;E&gt; synchArrayList = Collections.synchronizedList(new ArrayList&lt;E&gt;());
  Map&lt;K, V&gt; synchHashMap = Collections.synchronizedMap(new HashMap&lt;K, V&gt;());
  // 结果集合的方法使用锁加以保护，提供了线程的安全访问。
  // 应该确保没有任何线程通过原始的非同步方法访问数据结构。最便利的方法是确保不保存指向原始对象的引用，简单地构造一个结合并立即传递给包装器。
</code></pre>
</li>
</ul>
<h2 id="Callable-和-Future"><a href="#Callable-和-Future" class="headerlink" title="Callable 和 Future"></a>Callable 和 Future</h2><ul>
<li>Runnable 封装了一个异步运行的任务，可以把它想象成为一个没有参数和返回值的异步方法。</li>
<li><p>Callable 与 Runnable 类似，但是有返回值。Callable 接口是一个参数化的类型，只有一个方法 call.</p>
<pre><code class="Java">  public interface Callable&lt;V&gt; {
      V call() throws Exception;
  }
  // 类型参数是返回值的类型。
</code></pre>
</li>
<li><p>Future 保存异步计算的结果。</p>
<pre><code class="Java">  public interface Future&lt;V&gt; {
      V get() throws ...;
      V get(long timeout, TimeUnit unit) throws ...;
      void cancel(boolean mayInterrupt);
      boolean isCancelled();
      boolean isDone();
  }
</code></pre>
</li>
<li><p>FutureTask 包装器是一种非常便利的机制，可将 Callable 转换成 Future 和 Runnable, 它同时实现两者的接口。</p>
</li>
</ul>
<h2 id="执行器"><a href="#执行器" class="headerlink" title="执行器"></a>执行器</h2><ul>
<li>如果程序中创建了大量的生命期很短的线程，应该使用线程池（ thread pool ）</li>
<li><p>应该使用一个线程数“固定的”线程池以限制并发线程的总数。</p>
<pre><code class="Java">  // 执行器（ Executor ）类有许多静态工厂方法用来构建线程池。
  newCachedThreadPool // 必要时创建新线程；空闲线程会被保留 60 秒
  newFixedThreadPool // 该池包含固定数量的线程；空闲线程会一直被保留
  newSingleThreadExecutor // 只有一个线程的“池”，该线程顺序执行每一个提交任务
  newScheduledThreadPool // 用于预定执行而构建的固定线程池，替代 java.util.Timer
  newSingleThreadScheduleExecutor // 用于预定执行而构建的单线程“池”
</code></pre>
</li>
</ul>
<h3 id="线程池"><a href="#线程池" class="headerlink" title="线程池"></a>线程池</h3><ul>
<li><p>newCachedThreadPool , newFixedThreadPool , newSingleThreadExecutor 。这三个方法返回实现了 ExecutorService 接口的 ThreadPoolExecutor 类的对象。</p>
<pre><code class="Java">  // 将一个 Runnable 对象或 Callable 对象提交给 ExecutorService
  Future&lt;?&gt; submit(Runnable task)
  Future&lt;T&gt; submit(Runnable task, T result)
  Future&lt;T&gt; submit(Callable&lt;T&gt; task)

  // 当用完一个线程池的时候。
  shutdown // 该方法启动该池的关闭序列。被关闭的执行器不再接受新的任务。当所有任务都完成以后，线程池中的线程死亡。
  shutdownNow // 该池取消尚未开始的所有任务并试图中断正在运行的线程。
</code></pre>
</li>
<li><p>使用连接池应该做的事：</p>
<ul>
<li>调用 Executors 类中静态的方法 newCachedThreadPool 或 newFixedThreadPool</li>
<li>调用 submit 提交 Runnable 或 Callable 对象</li>
<li>如果想要取消一个任务，或如果提交 Callable 对象，那就要保存好返回的 Future 对象。</li>
<li>当不再提交任何任务时，调用 shutdown</li>
</ul>
</li>
</ul>
<h3 id="预定执行"><a href="#预定执行" class="headerlink" title="预定执行"></a>预定执行</h3><ul>
<li>ScheduledExecutorService 接口具有为预定执行（ Scheduled Execution ）或重复执行任务而设计的方法。</li>
</ul>
<h3 id="控制任务组"><a href="#控制任务组" class="headerlink" title="控制任务组"></a>控制任务组</h3><ul>
<li>invokeAny 方法提交所有对象到一个 Callable 对象的集合中，并返回某个已经完成了的任务的结果。</li>
<li><p>invokeAll 方法提交所有对象到一个 Callable 对象的集合中 ，并返回一个 Future 对象的列表，代表所有任务的解决方案。</p>
<pre><code class="Java">  List&lt;Callable&lt;T&gt;&gt; tasks = ...;
  List&lt;Future&lt;T&gt;&gt; results = executor.invokeAll(tasks);
  for(Future&lt;T&gt; result : result)
      processFurther(result.get());

  // 将结果按可获得的顺序保存起来更有实际意义。
  ExecutorCompletionService service = new  ExecutorCompletionService(executor);
  for(Callable&lt;T&gt; task : tasks) service.submit(task);
  for(int i = 0; i &lt; tasks.size(); i++)
      processFurther(service.take().get());
</code></pre>
</li>
</ul>
<h3 id="Fork-Join-框架（-Java-SE-7-）"><a href="#Fork-Join-框架（-Java-SE-7-）" class="headerlink" title="Fork-Join 框架（ Java SE 7 ）"></a>Fork-Join 框架（ Java SE 7 ）</h3><pre><code class="java">// 有一个处理任务，它可以很自然地分解为子任务
if(problemSize &lt; threshold)
    solve problem directly
else 
{
    break problem into subproblems
    recursively solve each subproblem
    combine the results
}
</code></pre>
<ul>
<li><p>完成这种递归计算，需要提供一个扩展 RecursiveTask<t> 的类或者提供一个扩展 RecursiveAction 的类。</t></p>
<pre><code class="Java">  class Counter extends RecursiveTask&lt;Integer&gt;
  {
      ...
      protected Integer compute()
      {
          if(to - from &lt; THRESHOLD)
          {
              solve problem directly
          }
      }
      else
      {
          int mid = (from + to) / 2
          Counter first = new Counter(values, from, mid, filter);
          Counter second = new Counter(values, mid, to, filter);
          invokeAll(first, second);
          return fist.join() + second.join();
      }
  }
</code></pre>
</li>
</ul>
<h2 id="同步器"><a href="#同步器" class="headerlink" title="同步器"></a>同步器</h2><h3 id="信号量"><a href="#信号量" class="headerlink" title="信号量"></a>信号量</h3><h3 id="倒计时门栓"><a href="#倒计时门栓" class="headerlink" title="倒计时门栓"></a>倒计时门栓</h3><h3 id="障栅"><a href="#障栅" class="headerlink" title="障栅"></a>障栅</h3><h3 id="交换器"><a href="#交换器" class="headerlink" title="交换器"></a>交换器</h3><h3 id="同步队列"><a href="#同步队列" class="headerlink" title="同步队列"></a>同步队列</h3><h2 id="线程与-Swing"><a href="#线程与-Swing" class="headerlink" title="线程与 Swing"></a>线程与 Swing</h2>
 
                <!-- Meta -->
                <div class="post-meta">
                    <hr>
                    <br>
                    <div class="post-tags">
                        
                            

<a href="/tags/Java核心技术卷一/">#Java核心技术卷一</a>


                        
                    </div>
                    <div class="post-date">
                        2017 年 02 月 14 日
                    </div>
                </div>
            </div>

            <!-- Comments -->
            <div class="col-lg-8 col-lg-offset-2 col-md-10 col-md-offset-1">
                <!-- Disqus Comments -->


            </div>
        </div>
    </div>
</article>
</section>

    <!-- Scripts -->
    <!-- jQuery -->
<script src="//cdn.bootcss.com/jquery/2.2.1/jquery.min.js"></script>
<!-- Bootstrap -->
<script src="//cdn.bootcss.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>

<script type="text/javascript">
	hljs.initHighlightingOnLoad();
	console.log('Hexo-theme-hollow designed by zchen9 http://www.chen9.info © 2015-' + (new Date()).getFullYear());
</script>

    <!-- Google Analytics -->
    

</body>

</html>